// 所有的使用工具类都存放在util.hpp中
#ifndef _M_UTIL_H_
#define _M_UTIL_H_

#include "logger.hpp"
#include <iostream>
#include <sstream> //stringstream头文件
#include <fstream> //文件操作
#include <string>
#include <vector>
#include <memory> //智能指针
#include <jsoncpp/json/json.h>
#include <mysql/mysql.h>

class mysql_util
{
    // static成员函数，使用时就不需要实例化类对象，可以直接调用

public:
    // 初始化
    // host主机地址
    static MYSQL *mysql_create(const std::string &host,
                               const std::string &username,
                               const std::string &password,
                               const std::string &dbname,
                               uint16_t port = 3306)
    {
        // 1.初始化Mysql句柄
        // MYSQL *mysql =mysql_init(MYSQL *mysql)如果传空会自己在堆上申请空间，来初始化句柄，并返回首地址
        MYSQL *mysql = mysql_init(NULL);
        if (mysql == NULL)
        {
            // 使用日志宏来打印日志信息
            ELOG("mysql init failed!");
            return NULL;
        }
        // 2. 连接服务器
        if (mysql_real_connect(mysql,
                               host.c_str(),
                               username.c_str(),
                               password.c_str(),
                               dbname.c_str(), port, NULL, 0) == NULL)
        {
            ELOG("connect mysql server failed : %s", mysql_error(mysql));
            mysql_close(mysql);
            return NULL;
        }
        // 3. 设置客户端字符集
        if (mysql_set_character_set(mysql, "utf8") != 0)
        {
            ELOG("set client character failed : %s", mysql_error(mysql));
            mysql_close(mysql);
            return NULL;
        }
        return mysql;
    }
    static bool mysql_exec(MYSQL *mysql, const std::string &sql)
    {
        int ret = mysql_query(mysql, sql.c_str());
        if (ret != 0)
        {
            ELOG("%s\n", sql.c_str());
            ELOG("mysql query failed : %s\n", mysql_error(mysql));
            return false;
        }
        return true;
    }
    static void mysql_destroy(MYSQL *mysql)
    {
        if (mysql != NULL)
        {
            mysql_close(mysql);
        }
        return;
    }
};

class json_util
{
public:
    // 序列化接口
    static bool serialize(const Json::Value &root, std::string &str)
    {
        // 1.实例化一个StreamWriterBuilder工厂类对象
        Json::StreamWriterBuilder swb;
        // 2.通过StreamWriteBuilder工厂类对象生产一个 StreamWriter对象，StreamWriter对象才是真正能够序列化的对象
        //   用智能指针管理new出来的对象
        std::unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());

        // 4.使用StreamWriter对象，对Json::Value中存储的数据进行序列化
        std::stringstream ss;
        int ret = sw->write(root, &ss);
        if (ret != 0)
        {
            ELOG("json serialize failed!!");
            return false;
        }
        str = ss.str();
        return true;
    }

    // 反序列化接口
    static bool unserialize(const std::string &str, Json::Value &root)
    {
        // 1.实例化一个CharReaderBuilder工厂类对象
        Json::CharReaderBuilder crb;
        // 2.使用CharReaderBuilder工厂类对象生产一个CharReader对象
        std::unique_ptr<Json::CharReader> cr(crb.newCharReader());
        // 3.定义一个Json::Value对象存储解析后的数据
        std::string err;
        // 4.使用CharReader对象进行json格式字符串str的反序列化
        // parse(char* start , char *end , Json::Value*val , string *err);
        // parse就是从start数据到end数据进行一个解析，把解析后的数据存放在value中，如果出错了将错误原因放到err中
        bool ret = cr->parse(str.c_str(), str.c_str() + str.size(), &root, &err);
        if (ret == false)
        {
            // 解析失败
            ELOG("json unserialize failed: %s", err.c_str());
            return false;
        }
        return true;
    }
};

class string_util
{
public:
    // 字符串分割函数
    // 使用特定字符将字符串分割·，将分割出来的子串存放到数组中
    // seq分隔符
    static int split(const std::string &src, const std::string &sep, std::vector<std::string> &res)
    {
        // 123,234,,,,345
        size_t pos, idx = 0;
        while (idx < src.size())
        {
            pos = src.find(sep, idx);
            if (pos == std::string::npos)
            {
                // 没有找到,字符串中没有间隔字符了，则跳出循环
                res.push_back(src.substr(idx));
                break;
            }
            if (pos == idx)
            {
                idx += sep.size();
                continue;
            }
            res.push_back(src.substr(idx, pos - idx));
            idx = pos + sep.size();
        }
        return res.size();
    }
};

class file_util
{
public:
    // 对文件数据进行读取，最终放到body中
    static bool read(const std::string &filename, std::string &body)
    {
        // 打开文件
        // ifstream默认是以只读的方式打开文件 以二进制形式打开
        std::ifstream ifs(filename, std::ios::binary);
        if (ifs.is_open() == false)
        {
            ELOG("%s file open failed!!", filename.c_str());
            return false;
        }

        // 获取文件大小
        // 把文件的读写位置移到文件末尾，然后再获取当前文件读写位置相对于文件起始的偏移量，就是文件的大小了
        size_t fsize = 0;
        ifs.seekg(0, std::ios::end); // 把读写位置跳转到文件末尾
        fsize = ifs.tellg();         // 获取当前位置据文件起始位置长度
        ifs.seekg(0, std::ios::beg); // 把读写位置跳转到文件起始

        body.resize(fsize); // 把body的大小调整成文件大小
        // 将文件所有数据读取出来
        ifs.read(&body[0], fsize);
        if (ifs.good() == false)
        {
            ELOG("%s file content failed!!", filename.c_str());
            ifs.close(); // 这里是打开了文件，读取失败，返回记得要释放资源
            return false;
        }
        // 关闭文件
        ifs.close();
    }
};

#endif
